// const fs = require('fs')
// const path = require('path')
// const { app } = require('electron')

// 使用ES模块导入语法
import path from 'path'
import fs from 'fs'
import { app } from 'electron'
import appConfig from '../config/app-config'

class Logger {
  constructor() {
    // 获取应用的可执行文件目录（而不是工作目录）
    this.exeDir = this.getExecutableDir()
    console.log('应用可执行文件目录:', this.exeDir)

    this.logDir = this.determineLogDir()
    // this.logDir = path.join(app.getPath('userData'), 'logs')
    // this.logDir = path.join(process.cwd(), 'logs') // 使用当前工作目录下的logs文件夹
    // 工作目录 process.cwd()：C:\Users\L\AppData\Local\Temp\34G7cI6cSJCEhFRaVNMYv7C1XCH
    console.log('日志目录:', this.logDir)

    this.logFile = path.join(this.logDir, `${new Date().toISOString().split('T')[0]}.log`)
    console.log('日志文件路径:', this.logFile)

    console.log(`[Logger 初始化] 当前环境: ${process.env.NODE_ENV}`)
    console.log(`[Logger 初始化] 尝试使用日志目录: ${this.logDir}`)

    // 根据环境设置日志级别
    // this.logLevel = process.env.NODE_ENV === 'development' ? 'debug' : 'info'
    // console.log('当前日志级别:', this.logLevel)
    // this.levels = { debug: 0, info: 1, warn: 2, error: 3, success: 1 } // 添加success级别

    // 确保日志目录存在
    this.ensureLogDirExists()
  }

  // 获取应用可执行文件所在目录
  getExecutableDir() {
    try {
      // 在生产环境中，获取应用的实际安装目录
      if (app.isPackaged) {
        // Electron打包后的应用，可通过process.execPath获取可执行文件路径
        return path.dirname(process.execPath)
      } else {
        // 开发环境仍使用当前工作目录
        return process.cwd()
      }
    } catch (error) {
      console.error(`[Logger错误] 获取可执行文件目录失败: ${error.message}`)
      return process.cwd()
    }
  }

  // 确定最终的日志目录
  determineLogDir() {
    // 1. 尝试使用可执行文件目录
    // const exeLogsDir = path.join(this.exeDir, 'logs')
    const logsDir = path.join(appConfig.workspacePath, 'logs')

    try {
      // 测试是否有写入权限
      const testFile = path.join(logsDir, 'writetest.tmp')

      // 确保目录存在
      if (!fs.existsSync(logsDir)) {
        fs.mkdirSync(logsDir, { recursive: true })
      }

      // 测试写入
      fs.writeFileSync(testFile, 'test')
      fs.unlinkSync(testFile)

      console.log(`[Logger] 可执行文件目录有写入权限: ${logsDir}`)
      return logsDir
    } catch (error) {
      console.error(`[Logger警告] 无法在可执行文件目录写入: ${error.message}`)
    }

    // 2. 回退到用户数据目录
    try {
      const userDataLogsDir = path.join(app.getPath('userData'), 'logs')
      console.log(`[Logger] 尝试使用用户数据目录: ${userDataLogsDir}`)
      return userDataLogsDir
    } catch (error) {
      console.error(`[Logger错误] 获取用户数据目录失败: ${error.message}`)
    }

    // 3. 最后的回退 - 使用系统临时目录
    const tempLogsDir = path.join(require('os').tmpdir(), '应用名称_logs')
    console.log(`[Logger] 回退到系统临时目录: ${tempLogsDir}`)
    return tempLogsDir
  }

  ensureLogDirExists() {
    try {
      if (!fs.existsSync(this.logDir)) {
        fs.mkdirSync(this.logDir, { recursive: true })
        console.log(`日志目录已创建: ${this.logDir}`)
      } else {
        console.log(`[Logger] 日志目录已存在: ${this.logDir}`)
      }
    } catch (error) {
      console.error(`[Logger错误] 创建日志目录失败: ${error.message}`)
      // 回退到Electron用户数据目录
      try {
        const userDataPath = app.getPath('userData')
        this.logDir = path.join(userDataPath, 'logs')
        console.log(`[Logger] 尝试使用备用日志目录: ${this.logDir}`)

        if (!fs.existsSync(this.logDir)) {
          fs.mkdirSync(this.logDir, { recursive: true })
          console.log(`[Logger] 备用日志目录已创建: ${this.logDir}`)
        }
      } catch (fallbackError) {
        console.error(`[Logger严重错误] 创建备用日志目录也失败: ${fallbackError.message}`)
      }
    }
  }

  // 格式化日志消息
  formatMessage(level, message) {
    // const timestamp = new Date().toISOString()
    // 取当地时间
    const timestamp = new Date().toLocaleString()
    return `[${timestamp}] [${level.toUpperCase()}] ${message}\n`
  }

  // 日志文件轮转，避免单个日志文件过大
  checkLogRotation() {
    fs.stat(this.logFile, (err, stats) => {
      if (err) return

      // 如果日志文件超过10MB，则创建新文件
      const MAX_SIZE = 10 * 1024 * 1024 // 10MB
      if (stats.size > MAX_SIZE) {
        const timestamp = new Date().getTime()
        const rotatedLogFile = path.join(
          this.logDir,
          `${new Date().toISOString().split('T')[0]}-${timestamp}.log`
        )

        try {
          fs.renameSync(this.logFile, rotatedLogFile)
          this.info(`日志文件已轮转: ${rotatedLogFile}`)
        } catch (error) {
          console.error('日志轮转失败:', error)
        }
      }
    })
  }

  // 写入日志到文件
  writeToFile(level, message) {
    try {
      const date = new Date().toISOString().split('T')[0]
      const logFile = path.join(this.logDir, `${date}.log`)
      const formattedMessage = this.formatMessage(level, message)

      fs.appendFileSync(logFile, formattedMessage + '\n')
      console.log(`[Logger] 日志已写入: ${logFile}`)

      // 检查文件大小并轮转
      this.checkLogRotation(logFile)
    } catch (error) {
      console.error(`[Logger写入错误] 无法写入日志文件: ${error.message}`)
    }
    console.log(message)
  }

  // 添加带上下文的日志记录方法
  success(context, message) {
    this.writeToFile('success', `[${context}] ${message}`)
  }

  // 添加对象序列化的日志方法
  logObject(level, context, obj) {
    try {
      const serializedObj = JSON.stringify(obj, null, 2)
      this.writeToFile(level, `[${context}] ${serializedObj}`)
    } catch (error) {
      this.error(`[${context}] 序列化对象失败: ${error.message}`)
    }
  }

  // 不同级别的日志方法
  info(message) {
    this.writeToFile('info', message)
  }

  warn(message) {
    this.writeToFile('warn', message)
  }

  error(message) {
    this.writeToFile('error', message)
  }

  debug(message) {
    this.writeToFile('debug', message)
  }
}

// 创建单例实例
// export default new Logger()

// 创建单例实例
const loggerInstance = new Logger()
export default loggerInstance

export { Logger }
